home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / codecs.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  17KB  |  623 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import __builtin__
  5. import sys
  6.  
  7. try:
  8.     from _codecs import *
  9. except ImportError:
  10.     why = None
  11.     raise SystemError('Failed to load the builtin codecs: %s' % why)
  12.  
  13. __all__ = [
  14.     'register',
  15.     'lookup',
  16.     'open',
  17.     'EncodedFile',
  18.     'BOM',
  19.     'BOM_BE',
  20.     'BOM_LE',
  21.     'BOM32_BE',
  22.     'BOM32_LE',
  23.     'BOM64_BE',
  24.     'BOM64_LE',
  25.     'BOM_UTF8',
  26.     'BOM_UTF16',
  27.     'BOM_UTF16_LE',
  28.     'BOM_UTF16_BE',
  29.     'BOM_UTF32',
  30.     'BOM_UTF32_LE',
  31.     'BOM_UTF32_BE',
  32.     'strict_errors',
  33.     'ignore_errors',
  34.     'replace_errors',
  35.     'xmlcharrefreplace_errors',
  36.     'register_error',
  37.     'lookup_error']
  38. BOM_UTF8 = '\xef\xbb\xbf'
  39. BOM_LE = BOM_UTF16_LE = '\xff\xfe'
  40. BOM_BE = BOM_UTF16_BE = '\xfe\xff'
  41. BOM_UTF32_LE = '\xff\xfe\x00\x00'
  42. BOM_UTF32_BE = '\x00\x00\xfe\xff'
  43. if sys.byteorder == 'little':
  44.     BOM = BOM_UTF16 = BOM_UTF16_LE
  45.     BOM_UTF32 = BOM_UTF32_LE
  46. else:
  47.     BOM = BOM_UTF16 = BOM_UTF16_BE
  48.     BOM_UTF32 = BOM_UTF32_BE
  49. BOM32_LE = BOM_UTF16_LE
  50. BOM32_BE = BOM_UTF16_BE
  51. BOM64_LE = BOM_UTF32_LE
  52. BOM64_BE = BOM_UTF32_BE
  53.  
  54. class CodecInfo(tuple):
  55.     
  56.     def __new__(cls, encode, decode, streamreader = None, streamwriter = None, incrementalencoder = None, incrementaldecoder = None, name = None):
  57.         self = tuple.__new__(cls, (encode, decode, streamreader, streamwriter))
  58.         self.name = name
  59.         self.encode = encode
  60.         self.decode = decode
  61.         self.incrementalencoder = incrementalencoder
  62.         self.incrementaldecoder = incrementaldecoder
  63.         self.streamwriter = streamwriter
  64.         self.streamreader = streamreader
  65.         return self
  66.  
  67.     
  68.     def __repr__(self):
  69.         return '<%s.%s object for encoding %s at 0x%x>' % (self.__class__.__module__, self.__class__.__name__, self.name, id(self))
  70.  
  71.  
  72.  
  73. class Codec:
  74.     
  75.     def encode(self, input, errors = 'strict'):
  76.         raise NotImplementedError
  77.  
  78.     
  79.     def decode(self, input, errors = 'strict'):
  80.         raise NotImplementedError
  81.  
  82.  
  83.  
  84. class IncrementalEncoder(object):
  85.     
  86.     def __init__(self, errors = 'strict'):
  87.         self.errors = errors
  88.         self.buffer = ''
  89.  
  90.     
  91.     def encode(self, input, final = False):
  92.         raise NotImplementedError
  93.  
  94.     
  95.     def reset(self):
  96.         pass
  97.  
  98.  
  99.  
  100. class BufferedIncrementalEncoder(IncrementalEncoder):
  101.     
  102.     def __init__(self, errors = 'strict'):
  103.         IncrementalEncoder.__init__(self, errors)
  104.         self.buffer = ''
  105.  
  106.     
  107.     def _buffer_encode(self, input, errors, final):
  108.         raise NotImplementedError
  109.  
  110.     
  111.     def encode(self, input, final = False):
  112.         data = self.buffer + input
  113.         (result, consumed) = self._buffer_encode(data, self.errors, final)
  114.         self.buffer = data[consumed:]
  115.         return result
  116.  
  117.     
  118.     def reset(self):
  119.         IncrementalEncoder.reset(self)
  120.         self.buffer = ''
  121.  
  122.  
  123.  
  124. class IncrementalDecoder(object):
  125.     
  126.     def __init__(self, errors = 'strict'):
  127.         self.errors = errors
  128.  
  129.     
  130.     def decode(self, input, final = False):
  131.         raise NotImplementedError
  132.  
  133.     
  134.     def reset(self):
  135.         pass
  136.  
  137.  
  138.  
  139. class BufferedIncrementalDecoder(IncrementalDecoder):
  140.     
  141.     def __init__(self, errors = 'strict'):
  142.         IncrementalDecoder.__init__(self, errors)
  143.         self.buffer = ''
  144.  
  145.     
  146.     def _buffer_decode(self, input, errors, final):
  147.         raise NotImplementedError
  148.  
  149.     
  150.     def decode(self, input, final = False):
  151.         data = self.buffer + input
  152.         (result, consumed) = self._buffer_decode(data, self.errors, final)
  153.         self.buffer = data[consumed:]
  154.         return result
  155.  
  156.     
  157.     def reset(self):
  158.         IncrementalDecoder.reset(self)
  159.         self.buffer = ''
  160.  
  161.  
  162.  
  163. class StreamWriter(Codec):
  164.     
  165.     def __init__(self, stream, errors = 'strict'):
  166.         self.stream = stream
  167.         self.errors = errors
  168.  
  169.     
  170.     def write(self, object):
  171.         (data, consumed) = self.encode(object, self.errors)
  172.         self.stream.write(data)
  173.  
  174.     
  175.     def writelines(self, list):
  176.         self.write(''.join(list))
  177.  
  178.     
  179.     def reset(self):
  180.         pass
  181.  
  182.     
  183.     def __getattr__(self, name, getattr = getattr):
  184.         return getattr(self.stream, name)
  185.  
  186.     
  187.     def __enter__(self):
  188.         return self
  189.  
  190.     
  191.     def __exit__(self, type, value, tb):
  192.         self.stream.close()
  193.  
  194.  
  195.  
  196. class StreamReader(Codec):
  197.     
  198.     def __init__(self, stream, errors = 'strict'):
  199.         self.stream = stream
  200.         self.errors = errors
  201.         self.bytebuffer = ''
  202.         self.charbuffer = ''
  203.         self.linebuffer = None
  204.  
  205.     
  206.     def decode(self, input, errors = 'strict'):
  207.         raise NotImplementedError
  208.  
  209.     
  210.     def read(self, size = -1, chars = -1, firstline = False):
  211.         if self.linebuffer:
  212.             self.charbuffer = ''.join(self.linebuffer)
  213.             self.linebuffer = None
  214.         
  215.         while True:
  216.             if chars < 0:
  217.                 if size < 0:
  218.                     if self.charbuffer:
  219.                         break
  220.                     
  221.                 elif len(self.charbuffer) >= size:
  222.                     break
  223.                 
  224.             elif len(self.charbuffer) >= chars:
  225.                 break
  226.             
  227.             if size < 0:
  228.                 newdata = self.stream.read()
  229.             else:
  230.                 newdata = self.stream.read(size)
  231.             data = self.bytebuffer + newdata
  232.             
  233.             try:
  234.                 (newchars, decodedbytes) = self.decode(data, self.errors)
  235.             except UnicodeDecodeError:
  236.                 exc = None
  237.                 if firstline:
  238.                     (newchars, decodedbytes) = self.decode(data[:exc.start], self.errors)
  239.                     lines = newchars.splitlines(True)
  240.                     if len(lines) <= 1:
  241.                         raise 
  242.                     
  243.                 else:
  244.                     raise 
  245.             except:
  246.                 firstline
  247.  
  248.             self.bytebuffer = data[decodedbytes:]
  249.             self.charbuffer += newchars
  250.             if not newdata:
  251.                 break
  252.                 continue
  253.             self
  254.         if chars < 0:
  255.             result = self.charbuffer
  256.             self.charbuffer = ''
  257.         else:
  258.             result = self.charbuffer[:chars]
  259.             self.charbuffer = self.charbuffer[chars:]
  260.         return result
  261.  
  262.     
  263.     def readline(self, size = None, keepends = True):
  264.         if self.linebuffer:
  265.             line = self.linebuffer[0]
  266.             del self.linebuffer[0]
  267.             if len(self.linebuffer) == 1:
  268.                 self.charbuffer = self.linebuffer[0]
  269.                 self.linebuffer = None
  270.             
  271.             if not keepends:
  272.                 line = line.splitlines(False)[0]
  273.             
  274.             return line
  275.         
  276.         if not size:
  277.             pass
  278.         readsize = 72
  279.         line = ''
  280.         while True:
  281.             data = self.read(readsize, firstline = True)
  282.             if data:
  283.                 if data.endswith('\r'):
  284.                     data += self.read(size = 1, chars = 1)
  285.                 
  286.             
  287.             line += data
  288.             lines = line.splitlines(True)
  289.             if lines:
  290.                 if len(lines) > 1:
  291.                     line = lines[0]
  292.                     del lines[0]
  293.                     if len(lines) > 1:
  294.                         lines[-1] += self.charbuffer
  295.                         self.linebuffer = lines
  296.                         self.charbuffer = None
  297.                     else:
  298.                         self.charbuffer = lines[0] + self.charbuffer
  299.                     if not keepends:
  300.                         line = line.splitlines(False)[0]
  301.                     
  302.                     break
  303.                 
  304.                 line0withend = lines[0]
  305.                 line0withoutend = lines[0].splitlines(False)[0]
  306.                 if line0withend != line0withoutend:
  307.                     self.charbuffer = ''.join(lines[1:]) + self.charbuffer
  308.                     if keepends:
  309.                         line = line0withend
  310.                     else:
  311.                         line = line0withoutend
  312.                     break
  313.                 
  314.             
  315.             if not data or size is not None:
  316.                 if line and not keepends:
  317.                     line = line.splitlines(False)[0]
  318.                 
  319.                 break
  320.             
  321.             if readsize < 8000:
  322.                 readsize *= 2
  323.                 continue
  324.         return line
  325.  
  326.     
  327.     def readlines(self, sizehint = None, keepends = True):
  328.         data = self.read()
  329.         return data.splitlines(keepends)
  330.  
  331.     
  332.     def reset(self):
  333.         self.bytebuffer = ''
  334.         self.charbuffer = u''
  335.         self.linebuffer = None
  336.  
  337.     
  338.     def seek(self, offset, whence = 0):
  339.         self.reset()
  340.         self.stream.seek(offset, whence)
  341.  
  342.     
  343.     def next(self):
  344.         line = self.readline()
  345.         if line:
  346.             return line
  347.         
  348.         raise StopIteration
  349.  
  350.     
  351.     def __iter__(self):
  352.         return self
  353.  
  354.     
  355.     def __getattr__(self, name, getattr = getattr):
  356.         return getattr(self.stream, name)
  357.  
  358.     
  359.     def __enter__(self):
  360.         return self
  361.  
  362.     
  363.     def __exit__(self, type, value, tb):
  364.         self.stream.close()
  365.  
  366.  
  367.  
  368. class StreamReaderWriter:
  369.     encoding = 'unknown'
  370.     
  371.     def __init__(self, stream, Reader, Writer, errors = 'strict'):
  372.         self.stream = stream
  373.         self.reader = Reader(stream, errors)
  374.         self.writer = Writer(stream, errors)
  375.         self.errors = errors
  376.  
  377.     
  378.     def read(self, size = -1):
  379.         return self.reader.read(size)
  380.  
  381.     
  382.     def readline(self, size = None):
  383.         return self.reader.readline(size)
  384.  
  385.     
  386.     def readlines(self, sizehint = None):
  387.         return self.reader.readlines(sizehint)
  388.  
  389.     
  390.     def next(self):
  391.         return self.reader.next()
  392.  
  393.     
  394.     def __iter__(self):
  395.         return self
  396.  
  397.     
  398.     def write(self, data):
  399.         return self.writer.write(data)
  400.  
  401.     
  402.     def writelines(self, list):
  403.         return self.writer.writelines(list)
  404.  
  405.     
  406.     def reset(self):
  407.         self.reader.reset()
  408.         self.writer.reset()
  409.  
  410.     
  411.     def __getattr__(self, name, getattr = getattr):
  412.         return getattr(self.stream, name)
  413.  
  414.     
  415.     def __enter__(self):
  416.         return self
  417.  
  418.     
  419.     def __exit__(self, type, value, tb):
  420.         self.stream.close()
  421.  
  422.  
  423.  
  424. class StreamRecoder:
  425.     data_encoding = 'unknown'
  426.     file_encoding = 'unknown'
  427.     
  428.     def __init__(self, stream, encode, decode, Reader, Writer, errors = 'strict'):
  429.         self.stream = stream
  430.         self.encode = encode
  431.         self.decode = decode
  432.         self.reader = Reader(stream, errors)
  433.         self.writer = Writer(stream, errors)
  434.         self.errors = errors
  435.  
  436.     
  437.     def read(self, size = -1):
  438.         data = self.reader.read(size)
  439.         (data, bytesencoded) = self.encode(data, self.errors)
  440.         return data
  441.  
  442.     
  443.     def readline(self, size = None):
  444.         if size is None:
  445.             data = self.reader.readline()
  446.         else:
  447.             data = self.reader.readline(size)
  448.         (data, bytesencoded) = self.encode(data, self.errors)
  449.         return data
  450.  
  451.     
  452.     def readlines(self, sizehint = None):
  453.         data = self.reader.read()
  454.         (data, bytesencoded) = self.encode(data, self.errors)
  455.         return data.splitlines(1)
  456.  
  457.     
  458.     def next(self):
  459.         data = self.reader.next()
  460.         (data, bytesencoded) = self.encode(data, self.errors)
  461.         return data
  462.  
  463.     
  464.     def __iter__(self):
  465.         return self
  466.  
  467.     
  468.     def write(self, data):
  469.         (data, bytesdecoded) = self.decode(data, self.errors)
  470.         return self.writer.write(data)
  471.  
  472.     
  473.     def writelines(self, list):
  474.         data = ''.join(list)
  475.         (data, bytesdecoded) = self.decode(data, self.errors)
  476.         return self.writer.write(data)
  477.  
  478.     
  479.     def reset(self):
  480.         self.reader.reset()
  481.         self.writer.reset()
  482.  
  483.     
  484.     def __getattr__(self, name, getattr = getattr):
  485.         return getattr(self.stream, name)
  486.  
  487.     
  488.     def __enter__(self):
  489.         return self
  490.  
  491.     
  492.     def __exit__(self, type, value, tb):
  493.         self.stream.close()
  494.  
  495.  
  496.  
  497. def open(filename, mode = 'rb', encoding = None, errors = 'strict', buffering = 1):
  498.     if encoding is not None and 'b' not in mode:
  499.         mode = mode + 'b'
  500.     
  501.     file = __builtin__.open(filename, mode, buffering)
  502.     if encoding is None:
  503.         return file
  504.     
  505.     info = lookup(encoding)
  506.     srw = StreamReaderWriter(file, info.streamreader, info.streamwriter, errors)
  507.     srw.encoding = encoding
  508.     return srw
  509.  
  510.  
  511. def EncodedFile(file, data_encoding, file_encoding = None, errors = 'strict'):
  512.     if file_encoding is None:
  513.         file_encoding = data_encoding
  514.     
  515.     data_info = lookup(data_encoding)
  516.     file_info = lookup(file_encoding)
  517.     sr = StreamRecoder(file, data_info.encode, data_info.decode, file_info.streamreader, file_info.streamwriter, errors)
  518.     sr.data_encoding = data_encoding
  519.     sr.file_encoding = file_encoding
  520.     return sr
  521.  
  522.  
  523. def getencoder(encoding):
  524.     return lookup(encoding).encode
  525.  
  526.  
  527. def getdecoder(encoding):
  528.     return lookup(encoding).decode
  529.  
  530.  
  531. def getincrementalencoder(encoding):
  532.     encoder = lookup(encoding).incrementalencoder
  533.     if encoder is None:
  534.         raise LookupError(encoding)
  535.     
  536.     return encoder
  537.  
  538.  
  539. def getincrementaldecoder(encoding):
  540.     decoder = lookup(encoding).incrementaldecoder
  541.     if decoder is None:
  542.         raise LookupError(encoding)
  543.     
  544.     return decoder
  545.  
  546.  
  547. def getreader(encoding):
  548.     return lookup(encoding).streamreader
  549.  
  550.  
  551. def getwriter(encoding):
  552.     return lookup(encoding).streamwriter
  553.  
  554.  
  555. def iterencode(iterator, encoding, errors = 'strict', **kwargs):
  556.     encoder = getincrementalencoder(encoding)(errors, **kwargs)
  557.     for input in iterator:
  558.         output = encoder.encode(input)
  559.         if output:
  560.             yield output
  561.             continue
  562.     
  563.     output = encoder.encode('', True)
  564.     if output:
  565.         yield output
  566.     
  567.  
  568.  
  569. def iterdecode(iterator, encoding, errors = 'strict', **kwargs):
  570.     decoder = getincrementaldecoder(encoding)(errors, **kwargs)
  571.     for input in iterator:
  572.         output = decoder.decode(input)
  573.         if output:
  574.             yield output
  575.             continue
  576.     
  577.     output = decoder.decode('', True)
  578.     if output:
  579.         yield output
  580.     
  581.  
  582.  
  583. def make_identity_dict(rng):
  584.     res = { }
  585.     for i in rng:
  586.         res[i] = i
  587.     
  588.     return res
  589.  
  590.  
  591. def make_encoding_map(decoding_map):
  592.     m = { }
  593.     for k, v in decoding_map.items():
  594.         if v not in m:
  595.             m[v] = k
  596.             continue
  597.         m[v] = None
  598.     
  599.     return m
  600.  
  601.  
  602. try:
  603.     strict_errors = lookup_error('strict')
  604.     ignore_errors = lookup_error('ignore')
  605.     replace_errors = lookup_error('replace')
  606.     xmlcharrefreplace_errors = lookup_error('xmlcharrefreplace')
  607.     backslashreplace_errors = lookup_error('backslashreplace')
  608. except LookupError:
  609.     strict_errors = None
  610.     ignore_errors = None
  611.     replace_errors = None
  612.     xmlcharrefreplace_errors = None
  613.     backslashreplace_errors = None
  614.  
  615. _false = 0
  616. if _false:
  617.     import encodings
  618.  
  619. if __name__ == '__main__':
  620.     sys.stdout = EncodedFile(sys.stdout, 'latin-1', 'utf-8')
  621.     sys.stdin = EncodedFile(sys.stdin, 'utf-8', 'latin-1')
  622.  
  623.